#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
from strSQL.fermentacion import strSelectFermentacion, strSelectFiltroFermentacion
from strSQL.basicas import strNextValCodigo 
from strSQL.maceracion import strSelectFiltroMaceracion
from strSQL.basicas import strSelectDetalleRelacion
from psycopg2 import connect
import completion
import comunes
from pyBusqueda import pyBusqueda
import proceso
import treetohtml
import config


(CODIGO_FERMENTACION,
 CODIGO_ESTANQUE,
 DESCRIPCION_ESTANQUE,
 FECHA,
 HORA,
 VOLUMEN_FERMENTACION,
 OBSERVACION,
 ORIGEN,
 CODIGO_TEMPORADA,
 DESCRIPCION_TEMPORADA) = range(10)

class wnFermentacion(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnProceso"):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnProceso.maximize()
            self.frm_padre = self.wnProceso
            self.padre 
        else:
            self.frm_padre = padre.frm_padre
            
        self.crea_columnas()

    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_FERMENTACION, "Código", "str"])
        columnas.append ([DESCRIPCION_ESTANQUE, "Estanque", "str"])
        columnas.append ([FECHA, "Fecha","dte"])
        columnas.append ([HORA, "Hora", "str"])
        columnas.append ([OBSERVACION, "Observación", "str"])
        columnas.append ([DESCRIPCION_TEMPORADA, "Temporada", "str"])
        
        self.carga_datos()
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeProceso)
        self.col_data = [(x[0],x[2]) for x in columnas]
        
    def on_btnImprimir_clicked(self, btn=None):
        t = treetohtml.TreeToHTML(self.treeProceso,"Fermentación", self.col_data)
        t.show()
        
    def carga_datos(self):
        self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectFermentacion)
        self.treeProceso.set_model(self.modelo)

    def on_btnAnadir_clicked(self, btn=None, data=None):
        dlg = dlgFermentacion(self.cnx, self.frm_padre, False)
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        dlg.entFecha.set_date(datetime.date.today())
        dlg.entHora.set_text("%s:%s" % (hora, minuto))
        dlg.editando = False
        response = dlg.dlgFermentacion.run()
        if response == gtk.RESPONSE_OK:
            self.carga_datos()
    
    def on_btnQuitar_clicked(self, btn=None):
        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        codigo = model.get_value(it, CODIGO_FERMENTACION)
        cuartel = model.get_value(it, DESCRIPCION_ESTANQUE)
        fecha = model.get_value(it, FECHA).split()[0]
        
        if dialogos.yesno("¿Desea eliminar la Fermentación <b>%s, cuartel %s del %s</b>?\nEsta acción no se puede deshacer\n" % (codigo, cuartel, fecha), self.frm_padre) == gtk.RESPONSE_YES:
            llaves = {'codigo_fermentacion':codigo}
            
            self.cursor.execute("begin")
            try:
                sql = ifd.deleteFromDict('traza.maceracion_fermentacion', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.detalle_fermentacion', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.control', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.aplicacion_producto', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.fermentacion', llaves)
                self.cursor.execute(sql, llaves)
                model.remove(it)
                self.cursor.execute("commit")
            except:
                self.cursor.execute("rollback")
                print sys.exc_info()[1]
                dialogos.error("<b>NO SE PUEDE ELIMINAR</b>\nLa Fermentación de la <b>%s</b> se encuentra relacionado con el Módulo Control. "%cuartel)
            
        
    def on_btnPropiedades_clicked(self, btn=None):

        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        
        dlg = dlgFermentacion(self.cnx, self.frm_padre, False, codigo_fermentacion=model.get_value(it, CODIGO_FERMENTACION))
        dlg.entCodigoFermentacion.set_text(model.get_value(it, CODIGO_FERMENTACION))
        dlg.codigo_estanque = dlg.pecEstanque.select(model.get_value(it, DESCRIPCION_ESTANQUE), 1)
        dlg.spnVolumen.set_value(float(model.get_value(it, VOLUMEN_FERMENTACION)))
        
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA).split()[0])
        
        dlg.entFecha.set_date(fecha)
        dlg.entHora.set_text(model.get_value(it, HORA))
        dlg.chkOrigen.set_active(model.get_value(it, ORIGEN) == "S")
        
        buf = dlg.txtObservacion.get_buffer()
        if len(model[0]) > OBSERVACION:
            texto = model.get_value(it, OBSERVACION)
        else:
            texto = ""
        buf.set_text(texto)
        dlg.txtObservacion.set_buffer(buf)
        
        dlg.aplicacion.carga_modelo(model.get_value(it, CODIGO_FERMENTACION), "fermentacion")
        dlg.control.carga_modelo(model.get_value(it, CODIGO_FERMENTACION), "fermentacion")
        
        dlg.relacion.carga_modelo(model.get_value(it, CODIGO_FERMENTACION))
        
        dlg.detalle.carga_modelo(model.get_value(it, CODIGO_FERMENTACION))
        where = "WHERE f.codigo_fermentacion <> %s" % model.get_value(it, CODIGO_FERMENTACION)
        
        dlg.detalle.filtro = strSelectFiltroFermentacion % where
        
        dlg.entTemporada.set_text(model.get_value(it, DESCRIPCION_TEMPORADA))
        dlg.codigo_temporada = model.get_value(it, CODIGO_TEMPORADA)
        dlg.pecTemporada.set_selected(True)
        
        dlg.editando = True
        
        response = dlg.dlgFermentacion.run()
        if response == gtk.RESPONSE_OK:
            self.modelo.clear()
            self.carga_datos()
            
    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Fermentación")
            
    def on_treeProceso_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()


class dlgFermentacion(GladeConnect):
    
    def __init__(self, conexion=None, padre=None, editando=None, codigo_fermentacion=None):
        GladeConnect.__init__(self, "glade/wnProceso.glade", "dlgFermentacion")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.editando = editando
        self.frm_padre = padre
        
        self.pecEstanque = completion.CompletionEstanque(self.entEstanque,
                self.sel_estanque,
                self.cnx)
        
        self.codigo_estanque = None

        self.aplicacion = proceso.vboxAplicacion(self.cnx, self)
        self.ntbFermentacion.append_page(self.aplicacion.vboxAplicacion, gtk.Label("Aplicación"))
        
        self.control = proceso.vboxControl(self.cnx, self)
        self.ntbFermentacion.append_page(self.control.vboxControl, gtk.Label("Control"))
        
        self.relacion = proceso.vboxFermentacionMaceracion(self.cnx, self)
        self.ntbFermentacion.append_page(self.relacion.vboxRelacion, gtk.Label("Detalle Maceración"))
        
        self.detalle = proceso.vboxDetalleFermentacion(self.cnx, self, codigo=codigo_fermentacion)
        self.ntbFermentacion.append_page(self.detalle.vboxRelacion, gtk.Label("Detalle Fermentación"))
        
        self.pecTemporada = completion.CompletionTemporada(self.entTemporada,
                self.sel_temporada,
                self.cnx)
        
        #<CODIGO comment="PARA SUGERIR LA MAS NUEVA">
        strSelectCodigoTemporada = """SELECT
                                        codigo_temporada,
                                        'Temporada ' || date_part('year', fecha_inicio) || '-' 
                                        || date_part('year', fecha_termino) as descripcion_temporada
                                        FROM traza.temporada
                                        WHERE abierta = TRUE
                                        ORDER BY codigo_temporada desc"""
                                        
        m = ifd.ListStoreFromSQL(self.cnx, strSelectCodigoTemporada)
        self.codigo_temporada = m[0][0]
        self.entTemporada.set_text(m[0][1])
        self.pecTemporada.set_selected(True)
        #</CODIGO>
        
        self.dlgFermentacion.show_all()

    def on_chkOrigen_toggled(self, btn=None):

        self.relacion.vboxRelacion.set_sensitive(not btn.get_active())
        if btn.get_active():
            self.relacion.modelo_relacion.clear()

        self.relacion.vboxRelacion.set_sensitive(not btn.get_active())
        self.detalle.vboxRelacion.set_sensitive(not btn.get_active())
        self.spnVolumen.set_sensitive(btn.get_active())
        if btn.get_active():
            self.detalle.modelo_relacion.clear()
            self.relacion.modelo_relacion.clear()

    def sel_estanque(self, completion, model, iter):
        self.codigo_estanque = model.get_value(iter, 1)
        
    def sel_temporada(self, completion, model, iter):
        self.codigo_temporada = model.get_value(iter, 1)
        
    def on_btnAceptar_clicked(self, btn=None, date=None, cnx=None):
        
        fecha = self.entFecha.get_date()
        hora = self.entHora.get_text()
        
        if hora == "":
            dialogos.error("El campo <b>Hora</b> no puede estar vacío")
            return

        if self.codigo_estanque is None:
            dialogos.error("Debe escoger un <b>Cuartel</b>")
            return
       
        #volumen = self.spnVolumen.get_value()
        if self.chkOrigen.get_active():
            volumen = self.spnVolumen.get_value()
        else:
            volumen = float(self.relacion.entTotal.get_text()) + float(self.detalle.entTotal.get_text()) 
        
        if volumen <= 0:
            dialogos.error("La <b>volumen</b> debe ser mayor que 0")
            return
        
        if self.entTemporada.get_text() == "":
            dialogos.error("La temporada no puede ser vacia.")
            return
       
        campos = {}
        llaves = {}
        campos['codigo_estanque'] = self.codigo_estanque
        campos['hora_fermentacion'] = hora
        campos['volumen'] = volumen
        campos['fecha_fermentacion'] = fecha.strftime("%Y/%m/%d")
        campos['codigo_temporada'] = self.codigo_temporada
        
        if self.chkOrigen.get_active():
            origen = "S"
        else:
            origen = "F"
        campos['origen'] = origen

        buf = self.txtObservacion.get_buffer()
        s, e = buf.get_bounds()
        if str(buf.get_text(s, e)) != "None" and str(buf.get_text(s, e)) != "":
            campos['orden_trabajo'] = buf.get_text(s, e)
        else:
            buf.set_text("")
            campos['orden_trabajo'] = buf.get_text(s, e)
        
        self.cursor.execute("BEGIN")
        
        try:
            if not self.editando:
                self.cursor.execute(strNextValCodigo % ("fermentacion", "fermentacion"))
                reg = self.cursor.fetchone()
                campos['codigo_fermentacion'] = reg[0]
                llaves['codigo_fermentacion'] = reg[0]
                sql = ifd.insertFromDict("traza.fermentacion", campos)
            else:
                llaves['codigo_fermentacion'] = self.entCodigoFermentacion.get_text()
                sql, campos=ifd.updateFromDict("traza.fermentacion", campos, llaves)
    
            self.cursor.execute(sql, campos)
            self.aplicacion.guarda_modelo(llaves['codigo_fermentacion'], "fermentacion")
            self.control.guarda_modelo(llaves['codigo_fermentacion'], "fermentacion")
            self.relacion.guarda_modelo("traza.maceracion_fermentacion", "codigo_fermentacion", llaves['codigo_fermentacion'], "codigo_maceracion")
            self.detalle.guarda_modelo("traza.detalle_fermentacion", "codigo_fermentacion", llaves['codigo_fermentacion'], "codigo_relacion")
            
        except:
            txt_error = sys.exc_info()[1]
            self.cursor.execute("ROLLBACK")
            dialogos.error("Ha ocurrido un error al intentar registrar los datos", str(txt_error))
            return
            
        self.cursor.execute("COMMIT")
        
        self.dlgFermentacion.hide()
        
    def on_btnCancelar_clicked(self, btn=None):
        self.dlgFermentacion.hide()
        
if __name__ == '__main__':
    cnx = connect("dbname=traza user=traza password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = wnFermentacion(cnx)
    
    gtk.main()
